package les_rivieres;

import java.util.ArrayList;

/**
 * 
 * @author Joel DURET, Ludivine ROYO et Gaetan ROYO
 * 
 *         Pour construire un lac: - on renseigne point d'entree/point de sortie - on ajoute ts les
 *         segments en partant du point d'entree, avec pour chaque segment : point amont segment s =
 *         point aval segment n-1 - une fois fini, l dernier segment est fait du dernier point aval
 *         et du point amont du point de sortie.
 */
public class lac {

	/*
	 * ATTRIBUTS
	 */

	/**
	 * point d'entree du lac
	 */
	private point pointE;

	/**
	 * point de sortie du lac
	 */
	private point pointS;

	/**
	 * Profondeur du lac
	 */
	private int profondeur;

	/**
	 * Collection de segment
	 */
	private ArrayList<segment_oriente> lesSegments;

	/**
	 * Le nom du lac
	 */
	private String nomLac;

	/**
	 * CONSTRUCT un segment a un point amont (point d'entree) et un point aval (point de sortie)
	 */
	public lac(point UnpointE, point UnpointS) {
		this.setpointE(UnpointE).setpointS(UnpointS);
	}

	public lac() {

	}

	/**
	 * Methode qui va ajouter notre segment a la liste. Cree la liste si celle-ci n'existe pas.
	 * 
	 * @param leSegment
	 */
	public void ajouterSegment(segment_oriente leSegment) {
		this.getLesSegments().add(leSegment);
	}

	@Override
	/**
	 * redefinition de la methode tostring pour retourner:
	 * 
	 * lac: point d'entree = lepointd'entree point de sortie = lepointdesortie
	 */
	public String toString() {
		String szChaine = "";
		if (this.getPointE() != null && this.getPointS() != null) {
			szChaine += "Le lac ";
			if (null != this.getNomLac() && "" != this.getNomLac()) {
				szChaine += "'" + this.getNomLac() + "'";
			} else {
				szChaine += "sans nom ";
			}

			szChaine += "<br>Sa longueur :" + this.getLargeur();
			szChaine += "<br>Son perimetre :" + this.getPerimetre();
			szChaine += "<br>Sa surface :" + this.getSuperficie();
		} else {
			return "";
		}
		return szChaine;
	}

	/*
	 * GETTERS / SETTERS
	 */

	public ArrayList<segment_oriente> getLesSegments() {
		if (lesSegments == null) {
			this.setLesSegments(new ArrayList<segment_oriente>());
		}
		return lesSegments;
	}

	public void setLesSegments(ArrayList<segment_oriente> lesSegments) {
		this.lesSegments = lesSegments;
	}

	/**
	 * retourne le point d'entree
	 * 
	 * @return _pointE
	 */
	public point getPointE() {
		return this.pointE;
	}

	/**
	 * donne une valeur au point d'entree
	 * 
	 * @param UnpointE
	 * @return this
	 */
	public lac setpointE(point UnpointE) {
		this.pointE = UnpointE;
		return this;
	}

	/**
	 * retourne le point de sortie
	 * 
	 * @return _pointS
	 */
	public point getPointS() {
		return this.pointS;
	}

	/**
	 * donne une valeur au point de sortie
	 * 
	 * @param UnpointS
	 * @return this
	 */
	public lac setpointS(point UnpointS) {
		this.pointS = UnpointS;
		return this;
	}

	/*
	 * METHODS
	 */

	/**
	 * retourne la superficie (non implemente) (on ne retiens pas la hauteur, on part du principe
	 * que la surface d'un lac est plane (niveau de l'eau))
	 * 
	 * @return double superficie
	 */
	public double getSuperficie() {
		// somme (x(i+1) - xi) * ((yi + y(i+1))/2)
		double nSuperficie = 0;
		for (segment_oriente segment : this.getLesSegments()) {
			point Point1 = segment.getPoint(0);
			point Point2 = segment.getPoint(1);
			// (x(i+1) - xi)
			double premier_calcul = (double) Point2.getX()
					- (double) Point2.getX();
			// ((yi + y(i+1))/2)
			double deuxieme_calcul = ((double) Point1.getY() + (double) Point2
					.getY()) / 2;
			// somme calcul1 * calcul2
			nSuperficie += (premier_calcul * deuxieme_calcul);
		}
		return nSuperficie;
	}

	/**
	 * retourne le perimetre du lac (non implemente)
	 * 
	 * @return double perimetre
	 */
	public double getPerimetre() {
		double nLongueur = 0;
		for (segment_oriente segment : this.getLesSegments()) {
			nLongueur += segment.getDistance();
		}
		return nLongueur;
	}

	/**
	 * retourne la profondeur du lac
	 * 
	 * @return this._Profondeur
	 */
	public int getProfondeur() {
		return this.profondeur;
	}

	/*
	 * 
	 * donne la longueur du lac (longueur entree le point d'entree et de sortie du lac)
	 */
	public double getLargeur() {
		segment UnSegment = new les_rivieres.segment(this.getPointE(),
				this.getPointS()) {
		};

		return UnSegment.getDistance();
	}

	/**
	 * modifie la profondeur au lac
	 * 
	 * @param int profondeur
	 * @return this
	 */
	public lac setProfondeur(int profondeur) {
		this.profondeur = profondeur;
		return this;
	}

	/**
	 * retourne le nom du lac
	 */
	public String getNomLac() {
		return nomLac;
	}

	/**
	 * donne un nom au lac
	 */
	public void setNomLac(String nomLac) {
		this.nomLac = nomLac;
	}
}
